Advanced

Operator Overloading

Supported types for overloading: Unary operators: +, --, !, ~, ++, Binary operators: +, --, *, /, %, &, |, ^, <<, Comparison operators: == , !=, <, >, <=, Implicit overloading: +=, --=, &&, Conversion operators: implicit, explicit

If == and !=get are overloaded then so should Equals(object obj) and int GetHashCode.

public struct Rational
{
 public Rational( int n, int d) { … }
 public int Numerator { get {…} }
 public int Denominator { get {…} }
 public override string ToString () { … }
 
 // *= is provided for free, if you implement operator *
 public static Rational operator* (Rational lhs, Rational rhs)
 {
  return new Rational(lhs.Numerator*rhs.Numerator,
   lhs.Denominator*rhs.Denominator);
 }
 
 // lossless conversions so Rational r = 2;
 public static implicit operator Rational (int i)
 {
  return new Rational (i,1);
 }
 
 // lossy conversions/exceptions double d = (double) r;
 public static explicit operator double (Rational r)
 {
  return r.Numerator / (double) r.Denominator
 }
}

    public struct Complex : IEquatable<Complex>
    {
        public Complex(double re, double im)
        {
            this.Re = re;
            this.Im = im;
        }

        public double Re { get; }
        public double Im { get; }

        public override string ToString() { 
            return String.Format("({0,5:0.0},{1,5:0.0}i)", Re, Im); 
        }

        public static Complex operator +(Complex lh, Complex rh)
        {
            return new Complex(lh.Re + rh.Re, lh.Im + rh.Im);
        }
        
        public static Complex operator -(Complex lh, Complex rh)
        {
            return new Complex(lh.Re - rh.Re, lh.Im - rh.Im);
        }

        public static bool operator ==(Complex lh, Complex rh)
        {
            return lh.Re.CompareTo(rh.Re) == 0 && lh.Im.CompareTo(rh.Im) == 0;
        }
        
        public static bool operator !=(Complex lh, Complex rh)
        {
            return lh.Re.CompareTo(rh.Re) != 0 || lh.Im.CompareTo(rh.Im) != 0;
        }

        public static Complex operator ++(Complex complex)
        {
            return new Complex(complex.Re + 1, complex.Im + 1);
        }

        public bool Equals(Complex other)
        {
            return Re.Equals(other.Re) && Im.Equals(other.Im);
        }

        public override bool Equals(object obj)
        {
            return obj is Complex other && Equals(other);
        }
        
        public override int GetHashCode()
        {
            return HashCode.Combine(Re, Im);
        }
    }

Extension Methods

Adding methods to existing types is hard and Subclassing is not always sensible which is why in C# you can use extension methods. The old way:

public static class StringExtensions
{
 public static string Without(string text, char ch)
 {
  return string.Join("", text.Split(ch));
 }
}

var text = "Hxellxo";
Console.WriteLine(StringExtensions.Without(text, 'x'));

Now with extension methods:

public static class StringExtensions
{
 // First param specifies which type you are extending
 public static String Without(this string text, char ch) 
 {
  return string.Join(("", text.Split(ch));
 }
}
var s = "Hexllxox";
var result = s.Without('x');
result = "Hexllxox".Without('x'
);

Yield

Just like generators in python.

public static IEnumerable<int> GenerateNumbers(int num)
{
 for(var i = 0; i < num; i++)
  yield return i;
}

static void Main()
{
 foreach (var a in GenerateNumbers(10))
  Console.WriteLine(a);
}

Instead of

public static IEnumerable<int> GenerateNumbers(int num)
{
 List<int> list = newList<int>();
 for(var i = 0; i < num; i++)
  list.Add(i);
 return list;
}